#include "EPlateau.h"
//#include "Case.h"
//#include "machiaParseur.cpp"

/*
ostream &operator<<( ostream &out, Piece p )
{
        out << p.numero << ": " << (int)p.haut << " - " << (int)p.droit << " - "<< (int)p.bas<<" - "<<(int)p.gauche  ;
        return out;
}
*/


EPlateau::~EPlateau()
{
        //cout<<"... : "<<this<<endl;
        //cout<<taille<<endl;
}


int EPlateau::getNbPiecesPosees()
{

        return nbPiecesPosees;

}

int EPlateau::getNbPiecesPossibles(Coord c)
{

        return nbPiecesPossible[c.x][c.y];

}


void EPlateau::parserPuzzle(const char * nomFichier)
{



        ifstream Puzzle(nomFichier, ios::in);  // on ouvre le fichier en lecture
        string ligne="";
        int i =0;
        getline(Puzzle, ligne);
        cout<<"ligne 1 : "<<ligne<<endl;
        int compteur=0;
        string temp="";

        while (i<ligne.size()) {

                if (ligne[i]==' ') {
                        i++;
                } else if (ligne[i]=='/'){
                	if (i<ligne.size()-1){
                		if (ligne[i+1]=='/'){
								i=ligne.size();
                			}
                		}
                	}

                else if (compteur==0) {
                        while (ligne[i]!=' ') {
                                temp+=ligne[i];
                                i++;
                        }
                        taille=atoi(temp.c_str());
						//resizage du plateau pour pouvoir poser les indices ci-apres
						/*plateau.resize(taille);
						nbPiecesPossible.resize(taille);
						for (int i = 0; i< taille; i++) {
								plateau[i].resize(taille);
								nbPiecesPossible[i].resize(taille);
						}



					coupsPossibles = new MatriceDesPossibles(listePieces, 1);
					cout<<"Matrice construite!"<<endl;

						initPiecesPossibles();
						*/

                        temp="";
                        i++;
                        compteur++;
                } else if (compteur==1) {
                        compteur++;
                        i++;
                } else if (compteur==2) {
                        while (ligne[i]!=' ') {
                                temp+=ligne[i];
                                i++;
                        }
                        nbColor=atoi(temp.c_str());

                        nbDemande.resize(nbColor,0);
                        nbOffre.resize(nbColor,0);

                        temp="";
                        i++;
                        compteur++;
                } else if (compteur == 3) {
                        while (ligne[i]!=' ') {
                                temp+=ligne[i];
                                i++;
                        }
                        nbIndices=atoi(temp.c_str());
                        temp="";
                        compteur++;
                }

        }

        //on va parser les indices;
        int p = 0;


		tableIndices = (indice *) malloc(sizeof(indice)*nbIndices);

        while (p<nbIndices) {
                i=0;

                getline(Puzzle, ligne);
                cout<<"ligne indice : "<<ligne<<endl;
                int compteur=0;
                temp="";
                while (i<ligne.size()) {

                        if (ligne[i]==' ') {
                                i++;
                        }
                          else if (ligne[i]=='/'){
                	if (i<ligne.size()-1){
                		if (ligne[i+1]=='/'){
								i=ligne.size();
                			}
                		}
                	}

                        else if (compteur==0) {

                                while (ligne[i]!=' ') {
                                        temp+=ligne[i];
                                        i++;
                                }
                                tableIndices[p].ligne=atoi(temp.c_str());
                                temp="";
                                i++;
                                compteur++;
                        } else if (compteur==1) {
                                while (ligne[i]!=' ') {
                                        temp+=ligne[i];
                                        i++;
                                }
                                tableIndices[p].colonne=atoi(temp.c_str());
                                temp="";
                                i++;
                                compteur++;
                        } else if (compteur==2) {
                                while (ligne[i]!=' ') {
                                        temp+=ligne[i];
                                        i++;
                                }
                                tableIndices[p].numeroPiece=atoi(temp.c_str());


                                temp="";
                                i++;
                                compteur++;
                        } else if (compteur == 3) {
                                while (ligne[i]!=' ') {
                                        temp+=ligne[i];
                                        i++;
                                }
                                tableIndices[p].rotation=atoi(temp.c_str());
                                temp="";
                                compteur++;
                                p++;


                        }

                }

        }



        bool valide;
        int cpt=1;
        ligne="";
        while (getline(Puzzle,ligne)) {
                cout<<"parsage de la ligne: "<<ligne<<"de taille: "<<ligne.size()<<endl<<endl;
                i=0;
                valide = false;
                compteur=0;
                Piece p;

                while (i<ligne.size()) {
                        cout<<i<<" : "<<compteur<<" : "<<ligne[i]<<endl;
                        if ((ligne[i]==' ')||(ligne[i]==',')) {

                        }

                         else if (ligne[i]=='/'){
                	if (i<ligne.size()-1){
                		if (ligne[i+1]=='/'){
								i=ligne.size();
                			}
                		}
                	}

                        //haut droit bas gauche
                        else {
                                while (i < ligne.size() && ligne[i]!=' ') {
                                        temp+=ligne[i];
                                        i++;
                                }
                                cout<<"temp : "<<temp<<endl;
                                if (compteur==0) {
                                        p.haut=atoi(temp.c_str());
                                        temp="";
                                        compteur++;
                                        if ((int)p.haut)
                                                nbOffre[(int)p.haut- 1] += 1;
                                        cout<<"haut: "<<(int)p.haut<<endl;
                                } else if (compteur==1) {
                                        p.droit=atoi(temp.c_str());
                                        temp="";
                                        compteur++;
                                        if ((int)p.droit)
                                                nbOffre[(int)p.droit- 1] += 1;
                                        cout<<"droit: "<<(int)p.droit<<endl;
                                }

                                else if (compteur==2) {
                                        p.bas=atoi(temp.c_str());
                                        temp="";
                                        compteur++;
                                        if ((int)p.bas)
                                                nbOffre[(int)p.bas - 1] += 1;
                                        cout<<"bas: "<<(int)p.bas<<endl;
                                }

                                else if (compteur==3) {
                                        valide = true;
                                        cout<<" on valide"<<endl;
                                        p.gauche=atoi(temp.c_str());
                                        temp="";
                                        compteur++;
                                        if ((int)p.gauche)
                                                nbOffre[(int)p.gauche - 1] += 1;
                                        cout<<"gauche: "<<(int)p.gauche<<endl;
                                }
                        }
                        i++;
                        cout<<"caractere parsé!"<<valide<<endl;
                }

                if (valide) {
                        p.numero=cpt;
                        p.estPose=false;
                        cpt++;
                        cout<<" et on push_back"<<endl;
                        listePieces.push_back(p);
                }
                ligne="";
        }



        cout<<"fin du parsage"<<endl;
}

const char * EPlateau::getFichier()
{
        return fichier;

}

EPlateau::EPlateau(const char * nomFichier)
{
        fichier=nomFichier;
		nbIndices =0;
        cout<<"on va parser le puzzle!"<<endl;
        parserPuzzle(nomFichier);

        cout<<"##affichage des pièces parsées##"<<endl;
        cout<<listePieces.size()<<endl;
        for (int i = 0; i <taille*taille; i++) {
                cout<<listePieces[i]<<endl;
        }
       plateau.resize(taille);
        nbPiecesPossible.resize(taille);
        for (int i = 0; i< taille; i++) {
                plateau[i].resize(taille);
                nbPiecesPossible[i].resize(taille);
                /*
                for (int j = 0; j< taille; j++) {
                        plateau[i][j]= ( * new Case());
                }
                */
       }

  /*     cout<<this<<" - "<<plateau[4].size()<<endl;
       int pause;
       cin>>pause;
*/


       coupsPossibles = new MatriceDesPossibles(listePieces, 1);
      cout<<"Matrice construite!"<<endl;

        cout<<coupsPossibles->getLpo().size()<<endl;
        for (int i=0; i<taille; i++) {
                for (int j=0; j<taille; j++) {
                        nbPiecesPossible[i][j] =(coupsPossibles->getLpo().size());
                }
        }
        //int pause;
        //cin>>pause;

        initPiecesPossibles();


        /*  nbDemande.resize(nbColor,0);
          nbOffre.resize(nbColor,0);
          for(int i=0; i<listePieces.size(); i++){
              nbOffre[listePieces[i].haut]++;
              nbOffre[listePieces[i].bas]++;
              nbOffre[listePieces[i].gauche]++;
              nbOffre[listePieces[i].droit]++;
          }
          */
        meilleurscore = taille * taille /2;
        valideOd = 0;

        for (int k = 0; k<nbIndices; k++){
        //	cout<<"on va jouer l'indice: "<<listePieces[tableIndices[k].numeroPiece]<<" a l'emplacement: "<<tableIndices[k].ligne<<" - "<<tableIndices[k].colonne<<" orientation: "<<(char)(tableIndices[k].rotation + 48)<<endl;
      //  	int pause;
       // 	cin>>pause;
//cout<<"taille du plateau: "<<plateau.size()<<" nbIndices: "<<nbIndices<<" k= "<<k<<" listepieces.size: "<<listePieces.size()<<endl;
//cout<<(char)(tableIndices[k].rotation + 48)<<" - "<<(char)(tableIndices[k].ligne + 48)<<" - "<<(char)(tableIndices[k].colonne + 48)<<endl;
//cout<<"plante?"<<endl;
		  jouer((char)(tableIndices[k].rotation), listePieces[tableIndices[k].numeroPiece-1], (char)(tableIndices[k].ligne),  (char)(tableIndices[k].colonne));
        }
/*
        for (int i = 0; i <nbPiecesPossible.size(); i ++){
        	for(int j = 0; j<nbPiecesPossible[i].size(); j++){
					cout<<nbPiecesPossible[i][j]<<" - ";
			}
			cout<<endl;
        }
*/
}

EPlateau::EPlateau(EPlateau * e)
{
        /*vector<vector<Case> > plateau;
        vector<vector<vector <Po> > > piecesPossible; //liste des pieces orientées posabe sur la case x,y
        vector<vector<int> > nbPiecesPossible; //nombre de pieces orientées posables sur la case x,y
        vector <Piece>  listePieces;
        int taille;
        int nbColor;
        int nbPiecesPosees;
        MatriceDesPossibles * coupsPossibles;
        */
        plateau = e->plateau;
        piecesPossible = e->piecesPossible;
        nbPiecesPossible = e->nbPiecesPossible;
        listePieces = e->listePieces;
        taille = e->taille;
        nbColor = e->nbColor;
        nbPiecesPosees = e->nbPiecesPosees;
        coupsPossibles = e->coupsPossibles;
        nbOffre = e->nbOffre;
        nbDemande = e->nbDemande;
        meilleurscore = e->meilleurscore;
        valideOd = e->valideOd;
		nbIndices = e->nbIndices;
		tableIndices = e->tableIndices;


}



int EPlateau::getTaille()
{
        return taille;
}



void EPlateau::initPiecesPossibles()
{
     //   cout<<"InitPiece: "<<plateau.size()<<endl;
        int taille = plateau.size();
        piecesPossible.resize(taille);
        for (int i = 0; i<taille; i++) {
                piecesPossible[i].resize(taille);
        }

        vector<Po> vecTemp = coupsPossibles->getLpo();

        cout<<vecTemp.size()<<endl;
        for (int i=0; i<vecTemp.size(); i++) {
                vecTemp[i].p.estPose = true; // la quetsion n'est pas de savoir si elle s'est posée mais si elle est posable...
        }

        for (int i = 0; i<taille; i++) {
                for (int j = 0; j<taille; j++) {
                        piecesPossible[i][j]=vecTemp;
                        cout<<piecesPossible[i][j].size()<< " ";
                }
                cout<<endl;
        }
        affichePlateau();
        cout<<"dans init Piece..."<<endl;
        //int pause;
        //cin>>pause;
        //tout à true.
        for (int i = 0; i<vecTemp.size(); i++) {
                if (poToPiece(vecTemp[i]).haut==0) {
                        for (int m=0;m<taille; m++) {
                                for (int n=1;n<taille; n++) {
                                        if (piecesPossible[m][n][i].p.estPose==true) {
                                                piecesPossible[m][n][i].p.estPose=false;
                                                nbPiecesPossible[m][n]--;
                                        }
                                }
                        }
                } else {
                        for (int n=0;n<taille; n++) {
                                if (piecesPossible[n][0][i].p.estPose==true) {
                                        piecesPossible[n][0][i].p.estPose=false;
                                        nbPiecesPossible[n][0]--;
                                }
                        }
                }
                if (poToPiece(vecTemp[i]).bas==0) {
                        for (int m=0;m<taille; m++) {
                                for (int n=0;n<taille-1; n++) {
                                        if (piecesPossible[m][n][i].p.estPose==true) {
                                                piecesPossible[m][n][i].p.estPose=false;
                                                nbPiecesPossible[m][n]--;
                                        }
                                }
                        }
                } else {
                        for (int n=0;n<taille; n++) {
                                if (piecesPossible[n][taille-1][i].p.estPose==true) {
                                        piecesPossible[n][taille - 1][i].p.estPose=false;
                                        nbPiecesPossible[n][taille-1]--;
                                }
                        }
                }
                if (poToPiece(vecTemp[i]).gauche==0) {
                        for (int m=1;m<taille; m++) {
                                for (int n=0;n<taille; n++) {
                                        if (piecesPossible[m][n][i].p.estPose==true) {
                                                piecesPossible[m][n][i].p.estPose=false;
                                                nbPiecesPossible[m][n]--;
                                        }
                                }
                        }
                } else {
                        for (int n=0;n<taille; n++) {
                                if (piecesPossible[0][n][i].p.estPose==true) {
                                        piecesPossible[0][n][i].p.estPose=false;
                                        nbPiecesPossible[0][n]--;
                                }
                        }
                }
                if (poToPiece(vecTemp[i]).droit==0) {
                        for (int m=0;m<taille-1; m++) {
                                for (int n=0;n<taille; n++) {
                                        if (piecesPossible[m][n][i].p.estPose==true) {
                                                piecesPossible[m][n][i].p.estPose=false;
                                                nbPiecesPossible[m][n]--;
                                        }
                                }
                        }
                } else {
                        for (int n=0;n<taille; n++) {
                                if (piecesPossible[taille-1][n][i].p.estPose==true) {
                                        piecesPossible[taille-1][n][i].p.estPose=false;
                                        nbPiecesPossible[taille-1][n]--;
                                }
                        }
                }
        }
        cout<<"INITALISATION TERMINEE"<<endl;
        int z = 0;
        for (int i=0;i<taille; i++) {
                for (int j=0;j<taille; j++) {
                        cout<<i<<" - "<<j<<" : "<<nbPiecesPossible[i][j]<<endl;
                        for (int k =0; k<piecesPossible[i][j].size(); k++) {
                                if (piecesPossible[i][j][k].p.estPose==true) {
                                        z++;
                                        cout<<poToPiece(piecesPossible[i][j][k])<<endl;
                                }
                        }
                        cout<<z<<endl;
                        z = 0;
                }
        }

}

vector<Po> EPlateau::listeCoupsJouable(Coord c)
{
        vector<Po> vTemp;
        vector<Po> vRetour;
        vTemp = piecesPossible[c.x][c.y];
        for (int i = 0; i<vTemp.size(); i++) {
                if (vTemp[i].p.estPose == true && listePieces[vTemp[i].p.numero].estPose == false) { //piece poswable sur la case et pas encore posée.
                        vRetour.push_back(vTemp[i]);
                }
        }
        return vRetour;
}

bool EPlateau::coupJouable(Po p, Coord c)
{
        /*
        if(!((piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)])==p)){
                cout<<"grave erreur!!!!"<<endl;
                cout<<"piece cherché : "<<poToPiece(p)<<endl;
                cout<<coupsPossibles->poToInt(p)<<endl;
                cout<<poToPiece(piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)])<<endl;
                cout<<poToPiece(piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)+1])<<endl;
                cout<<poToPiece(piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)-1])<<endl;
        } */
        //cout<<this <<" plateau.size: "<<plateau.size()<<" - "<<plateau[4].size()<<" piecesPossible.size(): "<<piecesPossible.size()<<" listePieces.size: "<<listePieces.size()<<" x: "<<(int)c.x<<" y: "<<(int)c.y<<endl;
        return ( (plateau[(int)c.x][(int)c.y].p.numero == 0) && (piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)]).p.estPose && listePieces[p.p.numero-1].estPose == false  );

}


bool EPlateau::coupJouable(Coup coup)
{
        /* Po poTemp;
         poTemp.orient = coup.orientation;
         poTemp.p = coup.p;
         return (piecesPossible[coup.place.x][coup.place.y][coupsPossibles->poToInt(poTemp)]).p.estPose && listePieces[coupsPossibles->poToInt(poTemp)].estPose == false  ;
         */
        return coupJouable(coupToPo(coup ), coup.place);

}


int EPlateau::getScore(){

	if(nbPiecesPosees==plateau.size()*plateau[0].size()){
        cout<<"I WIN"<<endl;
        sauvegarde(this,3);
        //int pause;
        //cin>>pause;
	}
	return nbPiecesPosees;
}

vector <Piece> EPlateau::getListePieces()
{
        return listePieces;
}

bool EPlateau::dansPlateau(Coord c)
{
        return dansPlateau((int)c.x, (int)c.y);
}

bool EPlateau::dansPlateau(int x, int y)
{
        return (x>=0 && y>=0 && x<taille && y<taille);
}

bool EPlateau::jouer(Coup coup)
{
        //cout<<"estposé? "<<listePieces[coup.p.numero-1].estPose<<endl;

        if (coupJouable(coup)) {
                majPossibles(coup);
                majOD(coup);
                plateau[coup.place.x][coup.place.y] = coupToPo(coup);
                nbPiecesPosees++;
                listePieces[coup.p.numero-1].estPose = true;
                nbPiecesPossible[coup.place.x][coup.place.y] =0;
                for (int n =0; n<piecesPossible[coup.place.x][coup.place.y].size(); n++) {
                        piecesPossible[coup.place.x][coup.place.y][n].p.estPose = false;
                }
                if (nbPiecesPosees == taille * taille) {
                        cout<<"WINNNNNNN"<<endl;
                        sauvegarde(this,25);
                        int pause;
                        cin>>pause;
                        exit(0);
                }
                return 1;

        } else {
                affichePlateau();
                //Coup c = coup;
                Po p =coupToPo(coup );
                Coord c = coup.place;
                cout<<(plateau[c.x][c.y].p.numero == 0)<<endl;
                cout<<(piecesPossible[c.x][c.y][coupsPossibles->poToInt(p)]).p.estPose<<endl;
                cout<<(listePieces[p.p.numero-1].estPose == false)<<endl;
                cout<<"Vous n'êtes pas autorisé à poser une pièçe ici ;-)"<<endl;
                cout<<coup<<endl;
                cout<<"pieces possibles sur la case : "<<nbPiecesPossible[coup.place.x][coup.place.y]<<endl;

                int pause;
                cin>>pause;
                return 0;
        }

}

bool EPlateau::jouer(char ori, Piece pi, char abs, char ord)
{
        Coup co;
        co.orientation = ori;
        co.p=pi;
        co.place.x=abs;
        co.place.y=ord;
        return jouer(co);
}

void EPlateau::affichePossibles(int x,int y)
{
        for (int i=0; i<piecesPossible[x][y].size(); i++) {
                if (piecesPossible[x][y][i].p.estPose == true) {
                        cout<<poToPiece(piecesPossible[x][y][i])<<endl;
                }
        }
}

void EPlateau::affichePlateau()
{
        cout <<"*** Plateau Eternity de taille: "<<taille<<" *** "<<endl;
        for (int i = 0; i< taille; i++) {
                for (int j = 0; j <taille; j++) {
                        cout<<plateau[j][i].p.numero<<"  ";
                }
                cout<<endl;
        }
        cout<<endl<<endl;
        cout<<"Meilleur score : "<< meilleurscore <<endl;

        if(nbPiecesPosees>=meilleurscore){
            meilleurscore=nbPiecesPosees;
            sauvegarde(this,20);
            cout<<"Nouveau meilleur score : "<< meilleurscore <<endl;
        }


        int cpt=0;
        /*    for (int i = 0; i< taille; i++) {
                    for (int j = 0; j <taille; j++) {
                            cout<<nbPiecesPossible[j][i]<<" = ";
                            for(int n=0; n<piecesPossible[j][i].size(); n++){
                                if(piecesPossible[j][i][n].p.estPose == true)
                                    cpt++;
                            }
                            cout<< cpt<<" ";
                            cpt=0;
                    }
                    cout<<endl;
            }
            sauvegarde(this,10);
            */
}

void EPlateau::setScore(int i)
{
        if (meilleurscore < i) {
                meilleurscore = i;
        }
}

int EPlateau::getMeilleurScore(){
    return meilleurscore;
}

Coord EPlateau::caseLaPlusContrainte()
{
        //cout<<"caseLaPlusContrainte"<<endl;
        Coord cTemp;
        cTemp.x=-1;
        cTemp.y=-1;
        int i;
        if (valideOd!=3) {
                for (i=0; i<nbColor && nbOffre[i]>=nbDemande[i]; i++) {
                        //  cout<<"boucle : "<<i<<endl;
                }
                //cout<<nbColor<<" =?"<<i<<endl;
                if (i==nbColor) {
                        int vTemp=plateau.size()*plateau.size()*4+1;
                        int vTemp2; //sert à memoriser la valeur de la case...
                        for (int i=0; i<plateau.size(); i++) {
                                for (int j=0; j< plateau[0].size(); j++) {
                                        //cout<<i<<" - "<<j<<" : "<<nbPiecesPossible[i][j]<<" ( "<<piecesPossible[i][j].size()<<" ) "<<endl;
                                        vTemp2 = nbPiecesPossible[i][j];
                                        /*  if(i==0 || j == 0 || i == taille-1 || j == taille-1 ){
                                              vTemp2 = vTemp2 * vTemp2 ;
                                          }
                                          if(i==0 && j == 0 || i == taille-1 && j == taille-1 || i==0 && j == taille-1 || i==taille-1 && j ==0  ){
                                              vTemp2 = vTemp2 * vTemp2 ;
                                          }
                                              	*/
                                        if (vTemp > vTemp2 && nbPiecesPossible[i][j]>0) {
                                                cTemp.x=i;
                                                cTemp.y=j;
                                                vTemp = nbPiecesPossible[i][j];
                                        } else if (nbPiecesPossible[i][j]==0 && plateau[i][j].p.numero ==0) {
                                                cTemp.x=-1;
                                                cTemp.y=-1;
                                                vTemp = -1;
                                        }

                                }
                        }
                        /*   if(cTemp.x==-1){
                         //      cout<<"plateau remplis?"<<endl;
                           //    affichePlateau();
                           //    sauvegarde(this,5);
                           }
                           */
                }
        }
        return cTemp;
}

vector< Po > EPlateau::vecteurCase(Coord c)
{
        return piecesPossible[c.x][c.y];
}

void EPlateau::majPossibles(Coup coup)
{
        //cout<<"maj possibles"<<endl;
        //cout<<taille<<endl;
        for (int i=0; i<taille; i++) {
                for (int j=0; j<taille; j++) {
                        if ( piecesPossible[i][j][coup.p.numero-1].p.estPose == true) {
                                piecesPossible[i][j][coup.p.numero-1].p.estPose = false;
                                nbPiecesPossible[i][j] --;
                        }
                        if (piecesPossible[i][j][coup.p.numero-1+ taille*taille].p.estPose == true) {
                                piecesPossible[i][j][coup.p.numero-1+ taille*taille].p.estPose = false;
                                nbPiecesPossible[i][j] --;
                        }

                        if (piecesPossible[i][j][coup.p.numero-1+ 2*taille*taille].p.estPose == true) {
                                piecesPossible[i][j][coup.p.numero-1+ 2*taille*taille].p.estPose = false;
                                nbPiecesPossible[i][j] --;
                        }
                        if (piecesPossible[i][j][coup.p.numero-1+ 3*taille*taille].p.estPose == true) {
                                piecesPossible[i][j][coup.p.numero-1+ 3*taille*taille].p.estPose = false;
                                nbPiecesPossible[i][j]--;
                        }
                }
        }
        //cout<<endl<<"maj possibles"<<endl;
        vector<Po> pTemp;
        Coord vecTemp[9]; //vecteur de coordonée sur lequel on bouclera...
//    vecTemp.resize(9);
        int n =0;
        for (int i = -1; i<2; i++) {
                for (int j = -1; j <2; j++) {
                        vecTemp[n].x = i;
                        vecTemp[n].y = j;
                        n++;
                }
        }
        //cout<<" n : "<<n<<endl;

        //cout<<"vecTemp rempli"<<endl;
        for (int m =0; m < 9; m++) {
                if (dansPlateau(coup.place + vecTemp[m]) && !(vecTemp[m].x==0 && vecTemp[m].y==0)) {
                        //cout<<"coord : "<<vecTemp[m]<<endl;

                        pTemp = coupsPossibles->vpo(coupToPo(coup),vecTemp[m]);
                        //if(pTemp.size() != piecesPossible[coup.place.x + vecTemp[m].x][coup.place.y + vecTemp[m].y].size()){
                        for (int z = 0; z<pTemp.size() ; z++) {
                                if (pTemp[z].p.estPose==false) {
                                        if (piecesPossible[coup.place.x + vecTemp[m].x][coup.place.y + vecTemp[m].y][z].p.estPose == true) { // A CONSERVER!
                                                //cout<<"j'enleve la piece "<<poToPiece(piecesPossible[coup.place.x + vecTemp[m].x][coup.place.y + vecTemp[m].y][z])<<" en "<<coup.place.x + vecTemp[m].x<<" - "<<coup.place.y + vecTemp[m].y<<endl;
                                                piecesPossible[coup.place.x + vecTemp[m].x][coup.place.y + vecTemp[m].y][z].p.estPose = false;
                                                // cout<<" ^^"<<endl;
                                                nbPiecesPossible[coup.place.x + vecTemp[m].x][coup.place.y + vecTemp[m].y] --;
                                        }
                                }
                        }
                        //}
                }
        }
//    cout<<vecTemp.size();
        //cout<<"fin maj possibles"<<endl;
}

void EPlateau::majOD(Coup coup)
{

        nbOffre[coup.p.haut -1]--;
        nbOffre[coup.p.bas -1]--;
        nbOffre[coup.p.gauche -1]--;
        nbOffre[coup.p.droit -1]--;

        Piece p = coupToPiece(coup);
        if (p.haut != 0 && plateau[coup.place.x][coup.place.y-1].p.numero !=0) {
                nbDemande[p.haut]++;
                if (nbDemande[p.haut]>nbOffre[p.haut]) {
                        valideOd=3;
                }
        } else {
                nbDemande[p.haut]--;
        }

        if (p.bas != 0 && plateau[coup.place.x][coup.place.y+1].p.numero !=0) {
                nbDemande[p.bas]++;
                if (nbDemande[p.bas]>nbOffre[p.bas]) {
                        valideOd=3;
                }
        } else {
                nbDemande[p.bas]--;
        }

        if (p.gauche != 0 && plateau[coup.place.x-1][coup.place.y].p.numero !=0) {
                nbDemande[p.gauche]++;
                if (nbDemande[p.gauche]>nbOffre[p.gauche]) {
                        valideOd=3;
                }
        } else {
                nbDemande[p.gauche]--;
        }

        if (p.droit != 0 && plateau[coup.place.x+1][coup.place.y].p.numero !=0) {
                nbDemande[p.droit]++;
                if (nbDemande[p.droit]>nbOffre[p.droit]) {
                        valideOd=3;
                }
        } else {
                nbDemande[p.droit]--;
        }

}

Po EPlateau::getPo(int x, int y)
{
        return plateau[x][y];
}

vector <Po> EPlateau::getLpo()
{
        return coupsPossibles->getLpo();
}

int EPlateau::poToInt(Po pieceOriente)
{
        return coupsPossibles->poToInt(pieceOriente);
}

